/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Modelo;

import java.util.Random;
import java.io.*;

/**
 *
 * @author vanesa
 */
public class TableroInicial6x6 {

    private static int [][] tablero=new int [6][6];
    private static int []fila=new int[6];
    private static int []columna=new int [6];
    private static int [] valores= new int [6];
    private static SolucionTablero6x6 aux=new SolucionTablero6x6();
    
    /** Constructor:
     * Inicializa el tablero con cero.
     */
    public TableroInicial6x6(int [][] tab){
        for(int i=0;i<6;i++)
            for(int j=0;j<6;j++){
                tablero[i][j]=0;
                tab[i][j]=0;
            }

    }
    
    /**
     * Método que se encarga de generar números aleatorios
     * mayores o iguales a cero y menores a seis.
     * @param v "Arreglo a que van a ir a parar los valores de los indices
     * para inicializar el tablero inicial del juego"
     * @return int [][] "retorna el array con los números aleatorios generado."
     */
    public int[] generarArraysAleatoriosIndices(int [] v){
	int i=0;
    int j;
    v[i]= new Random() . nextInt(7);
	for(i=1;i<v.length;i++){
		v[i]= new Random() . nextInt(7);
                    for(j=0;j<i;j++){
                            if((v[i]==v[j])||(v[i]>=6)){
                                    i--;
                            }
                    }
	}
        return v;
    }
    
    /**
     * Método que se encarga de generar números aleatorios
     * mayores a cero y menores o iguales a seis.
     * @param v "Arreglo a que van a ir a parar los valores para inicializar
     * el tablero inicial del juego"
     * @return int [][] "retorna el array con los números aleatorios generado."
     */
    public int[] generarArrayValoresAleatorios(int [] v){
	int i=0; 
    int j;
    v[i] = new Random() . nextInt(7);
	for(i=1;i<v.length;i++){
		v[i]= new Random() . nextInt(7);
                    for(j=0;j<i;j++){
                            if((v[i]==v[j])||(v[i]==0)||(v[i]>6)){
                                    i--;
                            }
                    }
	}
        return v;
    }

    

    
   

    /**
     * Método que genera el tablero inicial del juego Sudoku, con dimención 6x6.
     * @param cantInicial "Número de elementos que inicializarán el tablero."
     * @return int[][] "retorna el una matriz inicializada con valores entre 0 y 6."
     */
   public int[][] generarTableroIni(int cantInicial){
        fila=this.generarArraysAleatoriosIndices(fila);
        columna=this.generarArraysAleatoriosIndices(columna);
        valores=this.generarArrayValoresAleatorios(valores);
        boolean ctrlCol= false;
        boolean ctrlFila=false;
        boolean ctrlCuad=false;
        int i=0;
        int j=0;
        try{
        while(cantInicial>0){
            if(i<5) i++; 
            else {
                i=0;
                fila=this.generarArraysAleatoriosIndices(fila);
                columna=this.generarArraysAleatoriosIndices(columna);
            }
            if(j<5) j++; else j=0;
            ctrlCol= (!(aux.VerificarColumna(tablero,valores[j] ,fila[i])));
            ctrlFila= (!(aux.VerificarFila(tablero,valores[j] ,columna[j])));
            ctrlCuad= (!(aux.VerificarCuadricula(tablero,fila[i],columna[j],valores[j])));
            if (ctrlCol && ctrlFila && ctrlCuad){
                tablero[fila[i]][columna[j]]=valores[j];
                cantInicial--;
            }
            else{
                     if(!(aux.VerificarColumna(tablero,valores[i] ,columna[j]))&&
                       (!(aux.VerificarFila(tablero,valores[i] ,fila[i])))&&
                       (!(aux.VerificarCuadricula(tablero,columna[j],fila[i],valores[i])))){
                            tablero[columna[j]][fila[i]]=valores[i];
                            cantInicial--;
                    }
                 }
                
            }
        }catch(Exception ex){
           this.generarTableroIni(cantInicial);
        }
        return tablero;
    }
   /**Metodo que se encarga de verificar si el tablero inicial generado
    * tiene solución, en caso de no ternerla, genera un nuevo tablero y si 
    * éste tiene solución lo retorna.
    * @param cantInicial "Número de elementos que inicializarán el tablero."
    * @return int[][] "retorna el una matriz inicializada con valores entre 0 y 6."
    */
   public int[][] generarTablero(int cantInicial){
        int [][]aux= new int [6][6];
          aux=this.generarTableroIni(cantInicial);
          Verificar verificar= new Verificar(aux);
          if(verificar.SolEqualIni(aux)){
              for(int i=0;i<6;i++)
                for(int j=0;j<6;j++){
                    aux[i][j]=0;
                }
              generarTablero(cantInicial);
          }
          return aux;
   }

    public void mostrar(int [][] tablero){
        for(int i=0;i<6;i++){
            for(int j=0;j<6;j++){
                System.out.print("|");
                System.out.print(tablero[i][j]);
            }
            System.out.print("|");
            System.out.println();
        }
    }

   /* public static void main(String [] args){
        
        int [][] tablero2= new int [6][6];     
        TableroInicial6x6 tabI=new TableroInicial6x6(tablero2);
        tablero=tabI.generarTablero(20);
        tabI.mostrar(tablero);
    }*/
}
